fix(Segment): make segment.direction() return normalized direction by BenPinet · Pull Request #1321 · Geode-solutions/OpenGeode

BenPinet · 2026-08-14T08:34:13Z

No description provided.

github-actions · 2026-08-14T08:47:46Z

Cpp-Linter Report ⚠️

Some files did not pass the configured checks!

clang-tidy (v21.1.8) reports: 430 concern(s)

include/geode/geometry/basic_objects/segment.hpp:42:11: warning: [cppcoreguidelines-special-member-functions]

class 'GenericSegment' defines a copy constructor, a copy assignment operator, a move constructor and a move assignment operator but does not define a destructor
```
   42 |     class GenericSegment
      |           ^
```
include/geode/geometry/basic_objects/segment.hpp:72:11: warning: [cppcoreguidelines-special-member-functions]

class 'OwnerSegment' defines a copy constructor, a copy assignment operator, a move constructor and a move assignment operator but does not define a destructor
```
   72 |     class OwnerSegment : public GenericSegment< Point< dimension >, dimension >
      |           ^
```
include/geode/geometry/basic_objects/segment.hpp:90:11: warning: [cppcoreguidelines-special-member-functions]

class 'Segment' defines a copy constructor, a copy assignment operator, a move constructor and a move assignment operator but does not define a destructor
```
   90 |     class Segment : public GenericSegment< RefPoint< dimension >, dimension >
      |           ^
```
include/geode/geometry/basic_objects/segment.hpp:99:9: warning: [google-explicit-constructor]

single-argument constructors must be marked explicit to avoid unintentional implicit conversions
```
   99 |         Segment( const OwnerSegment< dimension >& other ) noexcept;
      |         ^
      |         explicit 
```
src/geode/geometry/barycentric_coordinates.cpp:38:24: warning: [readability-identifier-length]

variable name 'v0' is too short, expected at least 3 characters
```
   38 |         const Vector3D v0{ vertices[0], vertices[1] };
      |                        ^
```
src/geode/geometry/barycentric_coordinates.cpp:39:24: warning: [readability-identifier-length]

variable name 'v1' is too short, expected at least 3 characters
```
   39 |         const Vector3D v1{ vertices[0], vertices[2] };
      |                        ^
```
src/geode/geometry/barycentric_coordinates.cpp:40:24: warning: [readability-identifier-length]

variable name 'v2' is too short, expected at least 3 characters
```
   40 |         const Vector3D v2{ vertices[0], vertices[3] };
      |                        ^
```
src/geode/geometry/barycentric_coordinates.cpp:41:24: warning: [readability-identifier-length]

variable name 'v3' is too short, expected at least 3 characters
```
   41 |         const Vector3D v3{ vertices[0], point };
      |                        ^
```
src/geode/geometry/barycentric_coordinates.cpp:42:20: warning: [readability-identifier-length]

variable name 'a' is too short, expected at least 3 characters
```
   42 |         const auto a = v0.dot( v3 );
      |                    ^
```
src/geode/geometry/barycentric_coordinates.cpp:43:20: warning: [readability-identifier-length]

variable name 'b' is too short, expected at least 3 characters
```
   43 |         const auto b = v0.dot( v0 );
      |                    ^
```
src/geode/geometry/barycentric_coordinates.cpp:44:20: warning: [readability-identifier-length]

variable name 'c' is too short, expected at least 3 characters
```
   44 |         const auto c = v0.dot( v1 );
      |                    ^
```
src/geode/geometry/barycentric_coordinates.cpp:48:20: warning: [readability-identifier-length]

variable name 'g' is too short, expected at least 3 characters
```
   48 |         const auto g = v1.dot( v2 );
      |                    ^
```
src/geode/geometry/barycentric_coordinates.cpp:49:20: warning: [readability-identifier-length]

variable name 'h' is too short, expected at least 3 characters
```
   49 |         const auto h = v2.dot( v3 );
      |                    ^
```
src/geode/geometry/barycentric_coordinates.cpp:52:13: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '-'; add parentheses to explicitly specify the order of operations
```
   52 |             2 * c * d * g - b * g * g + i * b * f - i * c * c - d * d * f;
      |             ^~~~~~~~~~~~~
      |             (            )
```
src/geode/geometry/barycentric_coordinates.cpp:52:29: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '-'; add parentheses to explicitly specify the order of operations
```
   52 |             2 * c * d * g - b * g * g + i * b * f - i * c * c - d * d * f;
      |                             ^~~~~~~~~
      |                             (        )
```

src/geode/geometry/barycentric_coordinates.cpp:52:41: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '+'; add parentheses to explicitly specify the order of operations

   52 |             2 * c * d * g - b * g * g + i * b * f - i * c * c - d * d * f;
      |                                         ^~~~~~~~~
      |                                         (        )

src/geode/geometry/barycentric_coordinates.cpp:52:53: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '-'; add parentheses to explicitly specify the order of operations

   52 |             2 * c * d * g - b * g * g + i * b * f - i * c * c - d * d * f;
      |                                                     ^~~~~~~~~
      |                                                     (        )

src/geode/geometry/barycentric_coordinates.cpp:52:65: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '-'; add parentheses to explicitly specify the order of operations

   52 |             2 * c * d * g - b * g * g + i * b * f - i * c * c - d * d * f;
      |                                                                 ^~~~~~~~~~
      |                                                                 (        )

src/geode/geometry/barycentric_coordinates.cpp:56:28: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '-'; add parentheses to explicitly specify the order of operations
```
   56 |         const auto dg_ci = d * g - c * i;
      |                            ^~~~~
      |                            (    )
```
src/geode/geometry/barycentric_coordinates.cpp:56:36: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '-'; add parentheses to explicitly specify the order of operations
```
   56 |         const auto dg_ci = d * g - c * i;
      |                                    ^~~~~~
      |                                    (    )
```
src/geode/geometry/barycentric_coordinates.cpp:57:28: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '-'; add parentheses to explicitly specify the order of operations
```
   57 |         const auto cg_df = c * g - d * f;
      |                            ^~~~~
      |                            (    )
```
src/geode/geometry/barycentric_coordinates.cpp:57:36: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '-'; add parentheses to explicitly specify the order of operations
```
   57 |         const auto cg_df = c * g - d * f;
      |                                    ^~~~~~
      |                                    (    )
```
src/geode/geometry/barycentric_coordinates.cpp:58:28: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '-'; add parentheses to explicitly specify the order of operations
```
   58 |         const auto cd_bg = c * d - b * g;
      |                            ^~~~~
      |                            (    )
```
src/geode/geometry/barycentric_coordinates.cpp:58:36: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '-'; add parentheses to explicitly specify the order of operations
```
   58 |         const auto cd_bg = c * d - b * g;
      |                                    ^~~~~~
      |                                    (    )
```

src/geode/geometry/barycentric_coordinates.cpp:69:29: warning: [readability-function-cognitive-complexity]

function 'safe_tetrahedron_barycentric_coordinates' has cognitive complexity of 21 (threshold 10)

   69 |     std::array< double, 4 > safe_tetrahedron_barycentric_coordinates(
      |                             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:76:9: note: +1, including nesting penalty of 0, nesting level increased to 1
   76 |         catch( const OpenGeodeException& )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:82:13: note: +2, including nesting penalty of 1, nesting level increased to 2
   82 |             for( const auto f : LRange{ 4 } )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:84:40: note: +3, including nesting penalty of 2, nesting level increased to 3
   84 |                 const auto v0 = f == 3 ? 0 : f + 1;
      |                                        ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:85:41: note: +3, including nesting penalty of 2, nesting level increased to 3
   85 |                 const auto v1 = v0 == 3 ? 0 : v0 + 1;
      |                                         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:86:41: note: +3, including nesting penalty of 2, nesting level increased to 3
   86 |                 const auto v2 = v1 == 3 ? 0 : v1 + 1;
      |                                         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:89:17: note: +3, including nesting penalty of 2, nesting level increased to 3
   89 |                 if( area >= best_area )
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:100:40: note: +2, including nesting penalty of 1, nesting level increased to 2
  100 |             const auto v0 = facet == 3 ? 0 : facet + 1;
      |                                        ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:101:37: note: +2, including nesting penalty of 1, nesting level increased to 2
  101 |             const auto v1 = v0 == 3 ? 0 : v0 + 1;
      |                                     ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:102:37: note: +2, including nesting penalty of 1, nesting level increased to 2
  102 |             const auto v2 = v1 == 3 ? 0 : v1 + 1;
      |                                     ^

src/geode/geometry/barycentric_coordinates.cpp:84:28: warning: [readability-identifier-length]

variable name 'v0' is too short, expected at least 3 characters
```
   84 |                 const auto v0 = f == 3 ? 0 : f + 1;
      |                            ^
```
src/geode/geometry/barycentric_coordinates.cpp:85:28: warning: [readability-identifier-length]

variable name 'v1' is too short, expected at least 3 characters
```
   85 |                 const auto v1 = v0 == 3 ? 0 : v0 + 1;
      |                            ^
```
src/geode/geometry/barycentric_coordinates.cpp:86:28: warning: [readability-identifier-length]

variable name 'v2' is too short, expected at least 3 characters
```
   86 |                 const auto v2 = v1 == 3 ? 0 : v1 + 1;
      |                            ^
```

src/geode/geometry/barycentric_coordinates.cpp:96:13: warning: [cppcoreguidelines-pro-type-member-init]

uninitialized record type: 'lambdas'

   96 |             std::array< double, 4 > lambdas;
      |             ^                              
      |                                            {}

src/geode/geometry/barycentric_coordinates.cpp:100:24: warning: [readability-identifier-length]

variable name 'v0' is too short, expected at least 3 characters
```
  100 |             const auto v0 = facet == 3 ? 0 : facet + 1;
      |                        ^
```
src/geode/geometry/barycentric_coordinates.cpp:101:24: warning: [readability-identifier-length]

variable name 'v1' is too short, expected at least 3 characters
```
  101 |             const auto v1 = v0 == 3 ? 0 : v0 + 1;
      |                        ^
```
src/geode/geometry/barycentric_coordinates.cpp:102:24: warning: [readability-identifier-length]

variable name 'v2' is too short, expected at least 3 characters
```
  102 |             const auto v2 = v1 == 3 ? 0 : v1 + 1;
      |                        ^
```
src/geode/geometry/barycentric_coordinates.cpp:115:35: warning: [readability-identifier-length]

variable name 'v0' is too short, expected at least 3 characters
```
  115 |         const Vector< dimension > v0{ vertices[0], vertices[1] };
      |                                   ^
```
src/geode/geometry/barycentric_coordinates.cpp:116:35: warning: [readability-identifier-length]

variable name 'v1' is too short, expected at least 3 characters
```
  116 |         const Vector< dimension > v1{ vertices[0], vertices[2] };
      |                                   ^
```
src/geode/geometry/barycentric_coordinates.cpp:117:35: warning: [readability-identifier-length]

variable name 'v2' is too short, expected at least 3 characters
```
  117 |         const Vector< dimension > v2{ vertices[0], point };
      |                                   ^
```
src/geode/geometry/barycentric_coordinates.cpp:123:28: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '-'; add parentheses to explicitly specify the order of operations
```
  123 |         const auto denom = d00 * d11 - d01 * d01;
      |                            ^~~~~~~~~
      |                            (        )
```
src/geode/geometry/barycentric_coordinates.cpp:123:40: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '-'; add parentheses to explicitly specify the order of operations
```
  123 |         const auto denom = d00 * d11 - d01 * d01;
      |                                        ^~~~~~~~~~
      |                                        (        )
```

src/geode/geometry/barycentric_coordinates.cpp:134:29: warning: [readability-function-cognitive-complexity]

function 'safe_triangle_barycentric_coordinates' has cognitive complexity of 11 (threshold 10)

  134 |     std::array< double, 3 > safe_triangle_barycentric_coordinates(
      |                             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:142:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  142 |         catch( const OpenGeodeException& )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:148:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  148 |             for( const auto e : LRange{ 3 } )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:151:37: note: +3, including nesting penalty of 2, nesting level increased to 3
  151 |                     vertices[e == 2 ? 0 : e + 1] };
      |                                     ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:153:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  153 |                 if( length >= best_length )
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/barycentric_coordinates.cpp:165:31: note: +2, including nesting penalty of 1, nesting level increased to 2
  165 |             lambdas[edge == 2 ? 0 : edge + 1] = segment_lambdas[1];
      |                               ^

src/geode/geometry/barycentric_coordinates.cpp:160:13: warning: [cppcoreguidelines-pro-type-member-init]

uninitialized record type: 'lambdas'

  160 |             std::array< double, 3 > lambdas;
      |             ^                              
      |                                            {}

src/geode/geometry/basic_objects/segment.cpp:72:38: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
   72 |         return ( point0 + point1 ) / 2.;
      |                                      ^
```

src/geode/geometry/bounding_box.cpp:100:19: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '+'; add parentheses to explicitly specify the order of operations

  100 |                 + segment_extent * std::fabs( segment_direction.value( i ) );
      |                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      |                   (                                                         )

src/geode/geometry/bounding_box.cpp:130:24: warning: [readability-identifier-length]

variable name 'ii' is too short, expected at least 3 characters
```
  130 |             const auto ii = i == 2 ? 0 : i + 1;
      |                        ^
```

src/geode/geometry/bounding_box.cpp:155:26: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '+'; add parentheses to explicitly specify the order of operations

  155 |         const auto rhs = box_half_extent.value( 0 )
      |                          ^~~~~~~~~~~~~~~~~~~~~~~~~~
      |                          (
  156 |                              * std::fabs( line.direction().value( 1 ) )
      |                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      |                                                                        )

src/geode/geometry/bounding_box.cpp:157:28: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '+'; add parentheses to explicitly specify the order of operations

  157 |                          + box_half_extent.value( 1 )
      |                            ^~~~~~~~~~~~~~~~~~~~~~~~~~
      |                            (
  158 |                                * std::fabs( line.direction().value( 0 ) );
      |                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      |                                                                          )

src/geode/geometry/bounding_box.cpp:238:9: warning: [bugprone-easily-swappable-parameters]

2 adjacent parameters of 'BoundingBox' of similar type ('Point') are easily swapped by mistake

  238 |         Point< dimension > min, Point< dimension > max )
      |         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:238:28: note: the first parameter in the range is 'min'
  238 |         Point< dimension > min, Point< dimension > max )
      |                            ^~~
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:238:52: note: the last parameter in the range is 'max'
  238 |         Point< dimension > min, Point< dimension > max )
      |                                                    ^~~

src/geode/geometry/bounding_box.cpp:466:51: warning: [readability-function-cognitive-complexity]

function 'intersects<3U>' has cognitive complexity of 14 (threshold 10)

  466 |     bool opengeode_geometry_api BoundingBox< 3 >::intersects< 3 >(
      |                                                   ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:470:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  470 |         for( const auto v : LRange{ 3 } )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:472:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  472 |             if( contains( vertices[v].get() ) )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:477:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  477 |         if( !intersects( triangle.bounding_box() ) )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:490:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  490 |         if( !bbox_1d_projection( *this, triangle_normal )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:498:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  498 |         for( const auto i : LRange{ 3 } )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:509:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  509 |             if( !triangle_interval.intersects( box_interval ) )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:516:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  516 |         for( const auto i0 : LRange{ 3 } )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:518:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  518 |             for( const auto i1 : LRange{ 3 } )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:526:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  526 |                 if( !triangle_interval.intersects( box_interval ) )
      |                 ^

src/geode/geometry/bounding_box.cpp:516:25: warning: [readability-identifier-length]

variable name 'i0' is too short, expected at least 3 characters
```
  516 |         for( const auto i0 : LRange{ 3 } )
      |                         ^
```
src/geode/geometry/bounding_box.cpp:518:29: warning: [readability-identifier-length]

variable name 'i1' is too short, expected at least 3 characters
```
  518 |             for( const auto i1 : LRange{ 3 } )
      |                             ^
```

src/geode/geometry/bounding_box.cpp:537:51: warning: [readability-function-cognitive-complexity]

function 'epsilon_intersects<3U>' has cognitive complexity of 14 (threshold 10)

  537 |     bool opengeode_geometry_api BoundingBox< 3 >::epsilon_intersects< 3 >(
      |                                                   ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:541:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  541 |         for( const auto v : LRange{ 3 } )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:543:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  543 |             if( epsilon_contains( vertices[v].get() ) )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:548:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  548 |         if( !epsilon_intersects( triangle.bounding_box() ) )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:561:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  561 |         if( !bbox_1d_projection( *this, triangle_normal )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:569:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  569 |         for( const auto i : LRange{ 3 } )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:580:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  580 |             if( !triangle_interval.epsilon_intersects( box_interval ) )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:587:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  587 |         for( const auto i0 : LRange{ 3 } )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:589:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  589 |             for( const auto i1 : LRange{ 3 } )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/bounding_box.cpp:597:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  597 |                 if( !triangle_interval.epsilon_intersects( box_interval ) )
      |                 ^

src/geode/geometry/bounding_box.cpp:587:25: warning: [readability-identifier-length]

variable name 'i0' is too short, expected at least 3 characters
```
  587 |         for( const auto i0 : LRange{ 3 } )
      |                         ^
```
src/geode/geometry/bounding_box.cpp:589:29: warning: [readability-identifier-length]

variable name 'i1' is too short, expected at least 3 characters
```
  589 |             for( const auto i1 : LRange{ 3 } )
      |                             ^
```
src/geode/geometry/bounding_box.cpp:713:34: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  713 |         return ( min_ + max_ ) / 2.;
      |                                  ^
```
src/geode/geometry/bounding_box.cpp:750:25: warning: [readability-identifier-length]

variable name 'c' is too short, expected at least 3 characters
```
  750 |         for( const auto c : LRange{ dimension } )
      |                         ^
```

src/geode/geometry/bounding_box.cpp:768:20: warning: [readability-identifier-naming]

invalid case style for variable 'Pmin'

  768 |         const auto Pmin = point - min_;
      |                    ^~~~
      |                    pmin
  769 |         const auto Pmax = point - max_;
  770 |         auto inner_distance = std::numeric_limits< double >::max();
  771 |         for( const auto c : LRange{ dimension } )
  772 |         {
  773 |             const auto local_distance = std::min(
  774 |                 std::fabs( Pmin.value( c ) ), std::fabs( Pmax.value( c ) ) );
      |                            ~~~~
      |                            pmin

src/geode/geometry/bounding_box.cpp:769:20: warning: [readability-identifier-naming]

invalid case style for variable 'Pmax'

  769 |         const auto Pmax = point - max_;
      |                    ^~~~
      |                    pmax
  770 |         auto inner_distance = std::numeric_limits< double >::max();
  771 |         for( const auto c : LRange{ dimension } )
  772 |         {
  773 |             const auto local_distance = std::min(
  774 |                 std::fabs( Pmin.value( c ) ), std::fabs( Pmax.value( c ) ) );
      |                                                          ~~~~
      |                                                          pmax

src/geode/geometry/bounding_box.cpp:771:25: warning: [readability-identifier-length]

variable name 'c' is too short, expected at least 3 characters
```
  771 |         for( const auto c : LRange{ dimension } )
      |                         ^
```
src/geode/geometry/bounding_box.cpp:785:25: warning: [readability-identifier-length]

variable name 'c' is too short, expected at least 3 characters
```
  785 |         for( const auto c : LRange{ dimension } )
      |                         ^
```

src/geode/geometry/distance.cpp:91:9: warning: [readability-use-std-min-max]

use std::max instead of <=

   24 |         if( area2 <= 0 )
      |         ^~~~~~~~~~~~~~~~
      |         area2 = std::max<double>(area2, 0);
   25 |         {
      |         ~
   26 |             area2 = 0;
      |             ~~~~~~~~~~
   27 |         }
      |         ~

src/geode/geometry/distance.cpp:98:45: warning: [readability-identifier-length]

parameter name 'b1' is too short, expected at least 3 characters

   98 |     void get_min_edge02( double a11, double b1, std::array< double, 2 >& p )
      |                                             ^

src/geode/geometry/distance.cpp:98:74: warning: [readability-identifier-length]

parameter name 'p' is too short, expected at least 3 characters

   98 |     void get_min_edge02( double a11, double b1, std::array< double, 2 >& p )
      |                                                                          ^

src/geode/geometry/distance.cpp:115:10: warning: [readability-function-size]

function 'get_min_edge12' exceeds recommended size/complexity thresholds

  115 |     void get_min_edge12( double a01,
      |          ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:115:10: note: 6 parameters (threshold 4)

src/geode/geometry/distance.cpp:115:26: warning: [bugprone-easily-swappable-parameters]

2 adjacent parameters of 'get_min_edge12' of similar type ('double') are easily swapped by mistake

  115 |     void get_min_edge12( double a01,
      |                          ^~~~~~~~~~~
  116 |         double a11,
      |         ~~~~~~~~~~
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:115:33: note: the first parameter in the range is 'a01'
  115 |     void get_min_edge12( double a01,
      |                                 ^~~
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:116:16: note: the last parameter in the range is 'a11'
  116 |         double a11,
      |                ^~~

src/geode/geometry/distance.cpp:117:16: warning: [readability-identifier-length]

parameter name 'b1' is too short, expected at least 3 characters
```
  117 |         double b1,
      |                ^
```

src/geode/geometry/distance.cpp:118:9: warning: [bugprone-easily-swappable-parameters]

2 adjacent parameters of 'get_min_edge12' of similar type ('double') are easily swapped by mistake

  118 |         double f10,
      |         ^~~~~~~~~~~
  119 |         double f01,
      |         ~~~~~~~~~~
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:118:16: note: the first parameter in the range is 'f10'
  118 |         double f10,
      |                ^~~
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:119:16: note: the last parameter in the range is 'f01'
  119 |         double f01,
      |                ^~~

src/geode/geometry/distance.cpp:120:34: warning: [readability-identifier-length]

parameter name 'p' is too short, expected at least 3 characters
```
  120 |         std::array< double, 2 >& p )
      |                                  ^
```
src/geode/geometry/distance.cpp:122:20: warning: [readability-identifier-length]

variable name 'h0' is too short, expected at least 3 characters
```
  122 |         const auto h0 = a01 + b1 - f10;
      |                    ^
```
src/geode/geometry/distance.cpp:129:24: warning: [readability-identifier-length]

variable name 'h1' is too short, expected at least 3 characters
```
  129 |             const auto h1 = a11 + b1 - f01;
      |                        ^
```

src/geode/geometry/distance.cpp:142:10: warning: [readability-function-size]

function 'get_min_interior' exceeds recommended size/complexity thresholds

  142 |     void get_min_interior( const std::array< double, 2 >& p0,
      |          ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:142:10: note: 5 parameters (threshold 4)

src/geode/geometry/distance.cpp:142:59: warning: [readability-identifier-length]

parameter name 'p0' is too short, expected at least 3 characters

  142 |     void get_min_interior( const std::array< double, 2 >& p0,
      |                                                           ^

src/geode/geometry/distance.cpp:143:16: warning: [readability-identifier-length]

parameter name 'h0' is too short, expected at least 3 characters
```
  143 |         double h0,
      |                ^
```
src/geode/geometry/distance.cpp:144:40: warning: [readability-identifier-length]

parameter name 'p1' is too short, expected at least 3 characters
```
  144 |         const std::array< double, 2 >& p1,
      |                                        ^
```
src/geode/geometry/distance.cpp:145:16: warning: [readability-identifier-length]

parameter name 'h1' is too short, expected at least 3 characters
```
  145 |         double h1,
      |                ^
```
src/geode/geometry/distance.cpp:146:34: warning: [readability-identifier-length]

parameter name 'p' is too short, expected at least 3 characters
```
  146 |         std::array< double, 2 >& p )
      |                                  ^
```
src/geode/geometry/distance.cpp:150:16: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '+'; add parentheses to explicitly specify the order of operations
```
  150 |         p[0] = omz * p0[0] + z * p1[0];
      |                ^~~~~~~~~~~
      |                (          )
```
src/geode/geometry/distance.cpp:150:30: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '+'; add parentheses to explicitly specify the order of operations
```
  150 |         p[0] = omz * p0[0] + z * p1[0];
      |                              ^~~~~~~~~~
      |                              (        )
```
src/geode/geometry/distance.cpp:151:16: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '+'; add parentheses to explicitly specify the order of operations
```
  151 |         p[1] = omz * p0[1] + z * p1[1];
      |                ^~~~~~~~~~~
      |                (          )
```
src/geode/geometry/distance.cpp:151:30: warning: [readability-math-missing-parentheses]

'*' has higher precedence than '+'; add parentheses to explicitly specify the order of operations
```
  151 |         p[1] = omz * p0[1] + z * p1[1];
      |                              ^~~~~~~~~~
      |                              (        )
```

src/geode/geometry/distance.cpp:196:42: warning: [readability-function-cognitive-complexity]

function 'pivot_point_triangle_distance' has cognitive complexity of 44 (threshold 10)

  196 |     std::tuple< double, geode::Point3D > pivot_point_triangle_distance(
      |                                          ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:201:33: note: +1, including nesting penalty of 0, nesting level increased to 1
  201 |         const auto v1 = v0 == 2 ? 0 : v0 + 1;
      |                                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:202:33: note: +1, including nesting penalty of 0, nesting level increased to 1
  202 |         const auto v2 = v1 == 2 ? 0 : v1 + 1;
      |                                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:220:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  220 |         if( f00 >= 0 )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:222:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  222 |             if( f01 >= 0 )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:226:13: note: +1, nesting level increased to 2
  226 |             else
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:235:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  235 |                 if( h0 >= 0 )
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:239:17: note: +1, nesting level increased to 3
  239 |                 else
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:242:21: note: +4, including nesting penalty of 3, nesting level increased to 4
  242 |                     if( h1 <= 0 )
      |                     ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:246:21: note: +1, nesting level increased to 4
  246 |                     else
      |                     ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:253:14: note: +1, nesting level increased to 1
  253 |         else if( f01 <= 0 )
      |              ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:255:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  255 |             if( f10 <= 0 )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:260:13: note: +1, nesting level increased to 2
  260 |             else
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:268:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  268 |                 if( h0 >= 0 )
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:272:17: note: +1, nesting level increased to 3
  272 |                 else
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:275:21: note: +4, including nesting penalty of 3, nesting level increased to 4
  275 |                     if( h1 <= 0 )
      |                     ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:279:21: note: +1, nesting level increased to 4
  279 |                     else
      |                     ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:286:14: note: +1, nesting level increased to 1
  286 |         else if( f10 <= 0 )
      |              ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:296:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  296 |             if( h0 >= 0 )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:300:13: note: +1, nesting level increased to 2
  300 |             else
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:303:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  303 |                 if( h1 <= 0 )
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:307:17: note: +1, nesting level increased to 3
  307 |                 else
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:313:9: note: +1, nesting level increased to 1
  313 |         else
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:321:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  321 |             if( h0 >= 0 )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:325:13: note: +1, nesting level increased to 2
  325 |             else
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:328:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  328 |                 if( h1 <= 0 )
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:332:17: note: +1, nesting level increased to 3
  332 |                 else
      |                 ^

src/geode/geometry/distance.cpp:199:30: warning: [readability-identifier-length]

parameter name 'v0' is too short, expected at least 3 characters
```
  199 |         geode::local_index_t v0 )
      |                              ^
```
src/geode/geometry/distance.cpp:201:20: warning: [readability-identifier-length]

variable name 'v1' is too short, expected at least 3 characters
```
  201 |         const auto v1 = v0 == 2 ? 0 : v0 + 1;
      |                    ^
```
src/geode/geometry/distance.cpp:202:20: warning: [readability-identifier-length]

variable name 'v2' is too short, expected at least 3 characters
```
  202 |         const auto v2 = v1 == 2 ? 0 : v1 + 1;
      |                    ^
```
src/geode/geometry/distance.cpp:210:20: warning: [readability-identifier-length]

variable name 'b0' is too short, expected at least 3 characters
```
  210 |         const auto b0 = -diff.dot( edge0 );
      |                    ^
```
src/geode/geometry/distance.cpp:211:20: warning: [readability-identifier-length]

variable name 'b1' is too short, expected at least 3 characters
```
  211 |         const auto b1 = -diff.dot( edge1 );
      |                    ^
```

src/geode/geometry/distance.cpp:217:9: warning: [cppcoreguidelines-pro-type-member-init]

uninitialized record type: 'p'

  217 |         std::array< double, 2 > p0, p1, p;
      |         ^
note: this fix will not be applied because it overlaps with another fix

src/geode/geometry/distance.cpp:217:9: warning: [cppcoreguidelines-pro-type-member-init]

uninitialized record type: 'p0'
```
note: this fix will not be applied because it overlaps with another fix
```
src/geode/geometry/distance.cpp:217:9: warning: [cppcoreguidelines-pro-type-member-init]

uninitialized record type: 'p1'
```
note: this fix will not be applied because it overlaps with another fix
```
src/geode/geometry/distance.cpp:217:9: warning: [readability-isolate-declaration]

multiple declarations in a single statement reduces readability
```
  217 |         std::array< double, 2 > p0, p1, p;
      |         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
src/geode/geometry/distance.cpp:217:33: warning: [readability-identifier-length]

variable name 'p0' is too short, expected at least 3 characters
```
  217 |         std::array< double, 2 > p0, p1, p;
      |                                 ^
```
src/geode/geometry/distance.cpp:217:37: warning: [readability-identifier-length]

variable name 'p1' is too short, expected at least 3 characters
```
  217 |         std::array< double, 2 > p0, p1, p;
      |                                     ^
```
src/geode/geometry/distance.cpp:218:9: warning: [readability-isolate-declaration]

multiple declarations in a single statement reduces readability
```
  218 |         double dt1, h0, h1;
      |         ^~~~~~~~~~~~~~~~~~~
```

src/geode/geometry/distance.cpp:218:16: warning: [cppcoreguidelines-init-variables]

variable 'dt1' is not initialized

  218 |         double dt1, h0, h1;
      |                ^
note: this fix will not be applied because it overlaps with another fix

src/geode/geometry/distance.cpp:218:21: warning: [cppcoreguidelines-init-variables]

variable 'h0' is not initialized

  218 |         double dt1, h0, h1;
      |                     ^
note: this fix will not be applied because it overlaps with another fix

src/geode/geometry/distance.cpp:218:21: warning: [readability-identifier-length]

variable name 'h0' is too short, expected at least 3 characters

src/geode/geometry/distance.cpp:218:25: warning: [cppcoreguidelines-init-variables]

variable 'h1' is not initialized

  218 |         double dt1, h0, h1;
      |                         ^
note: this fix will not be applied because it overlaps with another fix

src/geode/geometry/distance.cpp:218:25: warning: [readability-identifier-length]

variable name 'h1' is too short, expected at least 3 characters

src/geode/geometry/distance.cpp:348:9: warning: [readability-function-cognitive-complexity]

function 'find_non_colocated_triangles_points' has cognitive complexity of 11 (threshold 10)

  348 |         find_non_colocated_triangles_points( const geode::Triangle3D& triangle0,
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:356:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  356 |         for( const auto vertex0 : geode::LRange{ 3 } )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:358:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  358 |             for( const auto vertex1 : geode::LRange{ 3 } )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:360:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  360 |                 if( geode::point_point_distance(
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:373:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  373 |         for( const auto v : geode::LRange{ 3 } )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:375:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  375 |             if( !colocated.first[v] )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:379:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  379 |             if( !colocated.second[v] )
      |             ^

src/geode/geometry/distance.cpp:388:9: warning: [readability-function-cognitive-complexity]

function 'test_triangle_non_common_edges' has cognitive complexity of 15 (threshold 10)

  388 |         test_triangle_non_common_edges(
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:399:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  399 |         for( const auto v0 : geode::LRange{ 3 } )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:401:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  401 |             if( v0 == non_colocated0 )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:407:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  407 |             for( const auto v1 : geode::LRange{ 3 } )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:409:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  409 |                 if( v1 == non_colocated1 )
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:417:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  417 |                 if( cur_pt0.inexact_equal( vertices0[v0] )
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:418:21: note: +1
  418 |                     || cur_pt1.inexact_equal( vertices1[v1] ) )
      |                     ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:422:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  422 |                 if( cur_distance < min_distance )
      |                 ^

src/geode/geometry/distance.cpp:399:25: warning: [readability-identifier-length]

variable name 'v0' is too short, expected at least 3 characters
```
  399 |         for( const auto v0 : geode::LRange{ 3 } )
      |                         ^
```
src/geode/geometry/distance.cpp:407:29: warning: [readability-identifier-length]

variable name 'v1' is too short, expected at least 3 characters
```
  407 |             for( const auto v1 : geode::LRange{ 3 } )
      |                             ^
```

src/geode/geometry/distance.cpp:433:58: warning: [readability-function-cognitive-complexity]

function 'test_close_triangles' has cognitive complexity of 12 (threshold 10)

  433 |     std::tuple< double, geode::Point3D, geode::Point3D > test_close_triangles(
      |                                                          ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:442:9: note: +1, including nesting penalty of 0, nesting level increased to 1
  442 |         for( const auto vertex0 : non_colocated_points )
      |         ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:444:13: note: +2, including nesting penalty of 1, nesting level increased to 2
  444 |             for( const auto vertex1 : non_colocated_points )
      |             ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:446:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  446 |                 if( vertex0 == vertex1 )
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:450:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  450 |                 if( geode::point_point_distance( base_vertices[vertex0].get(),
      |                 ^
/__w/OpenGeode/OpenGeode/src/geode/geometry/distance.cpp:467:17: note: +3, including nesting penalty of 2, nesting level increased to 3
  467 |                 if( cur_distance < min_distance )
      |                 ^

src/geode/geometry/distance.cpp:489:42: warning: [readability-identifier-naming]

invalid case style for variable 'P1mP0'

  489 |         const geode::Vector< dimension > P1mP0{ segment0.vertices()[0],
      |                                          ^~~~~
      |                                          p1m_p0
  490 |             segment0.vertices()[1] };
  491 |         const geode::Vector< dimension > Q1mQ0{ segment1.vertices()[0],
  492 |             segment1.vertices()[1] };
  493 |         const geode::Vector< dimension > P0mQ0{ segment1.vertices()[0],
  494 |             segment0.vertices()[0] };
  495 |         const auto a = P1mP0.dot( P1mP0 );
      |                        ~~~~~      ~~~~~
      |                        p1m_p0     p1m_p0
  496 |         const auto b = P1mP0.dot( Q1mQ0 );
      |                        ~~~~~
      |                        p1m_p0
  497 |         const auto c = Q1mQ0.dot( Q1mQ0 );
  498 |         const auto d = P1mP0.dot( P0mQ0 );
      |                        ~~~~~
      |                        p1m_p0

src/geode/geometry/distance.cpp:491:42: warning: [readability-identifier-naming]

invalid case style for variable 'Q1mQ0'

  491 |         const geode::Vector< dimension > Q1mQ0{ segment1.vertices()[0],
      |                                          ^~~~~
      |                                          q1m_q0
  492 |             segment1.vertices()[1] };
  493 |         const geode::Vector< dimension > P0mQ0{ segment1.vertices()[0],
  494 |             segment0.vertices()[0] };
  495 |         const auto a = P1mP0.dot( P1mP0 );
  496 |         const auto b = P1mP0.dot( Q1mQ0 );
      |                                   ~~~~~
      |                                   q1m_q0
  497 |         const auto c = Q1mQ0.dot( Q1mQ0 );
      |                        ~~~~~      ~~~~~
      |                        q1m_q0     q1m_q0
  498 |         const auto d = P1mP0.dot( P0mQ0 );
  499 |         const auto e = Q1mQ0.dot( P0mQ0 );
      |                        ~~~~~
      |                        q1m_q0

src/geode/geometry/distance.cpp:493:42: warning: [readability-identifier-naming]

invalid case style for variable 'P0mQ0'

  493 |         const geode::Vector< dimension > P0mQ0{ segment1.vertices()[0],
      |                                          ^~~~~
      |                                          p0m_q0
  494 |             segment0.vertices()[0] };
  495 |         const auto a = P1mP0.dot( P1mP0 );
  496 |         const auto b = P1mP0.dot( Q1mQ0 );
  497 |         const auto c = Q1mQ0.dot( Q1mQ0 );
  498 |         const auto d = P1mP0.dot( P0mQ0 );
      |                                   ~~~~~
      |                                   p0m_q0
  499 |         const auto e = Q1mQ0.dot( P0mQ0 );
      |                                   ~~~~~
      |                                   p0m_q0

src/geode/geometry/distance.cpp:495:20: warning: [readability-identifier-length]

variable name 'a' is too short, expected at least 3 characters
```
  495 |         const auto a = P1mP0.dot( P1mP0 );
      |                    ^
```
src/geode/geometry/distance.cpp:496:20: warning: [readability-identifier-length]

variable name 'b' is too short, expected at least 3 characters
```
  496 |         const auto b = P1mP0.dot( Q1mQ0 );
      |                    ^
```
src/geode/geometry/distance.cpp:497:20: warning: [readability-identifier-length]

variable name 'c' is too short, expected at least 3 characters
```
  497 |         const auto c = Q1mQ0.dot( Q1mQ0 );
      |                    ^
```
src/geode/geometry/distance.cpp:500:20: warning: [readability-identifier-length]

variable name 'ac' is too short, expected at least 3 characters
```
  500 |         const auto ac = a * c;
      |                    ^
```
src/geode/geometry/distance.cpp:501:20: warning: [readability-identifier-length]

variable name 'bb' is too short, expected at least 3 characters
```
  501 |         const auto bb = b * b;
      |                    ^
```
src/geode/geometry/distance.cpp:502:9: warning: [readability-isolate-declaration]

multiple declarations in a single statement reduces readability
```
  502 |         double s, t, nd, bmd, bte, ctd, bpe, ate, btd;
      |         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```

Have any feedback or feature suggestions? Share it here.

panquez · 2026-08-14T10:13:40Z

+        const auto P1mP0 = segment0.direction() * segment0.length();
+        const auto Q1mQ0 = segment1.direction() * segment1.length();


maybe better to create a vector (segment1.p0 -> segment1.p1) instead of doing the normalization then the denormalisation

panquez · 2026-08-14T10:13:46Z

            const InfiniteLine< dimension >& line )
    {
-        const auto segDirection = segment.direction();
+        const auto segDirection = segment.direction() * segment.length();


BotellaA · 2026-08-18T15:33:30Z

🎉 This PR is included in version 18.0.0-rc.1 🎉

The release is available on GitHub release

Your semantic-release bot 📦🚀

BotellaA · 2026-08-19T00:12:56Z

🎉 This PR is included in version 18.0.0 🎉

The release is available on GitHub release

Your semantic-release bot 📦🚀

fix(Segment): make segment.direction() return normalized direction

76c6a37

BenPinet requested a review from panquez August 14, 2026 08:34

panquez approved these changes Aug 14, 2026

View reviewed changes

BenPinet added 4 commits August 14, 2026 13:16

pierre's comment

938786b

fix compilation

0ee21db

fix compilation

dd9f120

fix test

64d3a19

BotellaA merged commit c343bf5 into v18 Aug 14, 2026
19 checks passed

BotellaA deleted the fix/remove_segment_normalized_direction branch August 14, 2026 12:55

BotellaA added the released on @next label Aug 18, 2026

BotellaA added the released label Aug 19, 2026

Navigation Menu

Uh oh!

Uh oh!

fix(Segment): make segment.direction() return normalized direction - #1321

fix(Segment): make segment.direction() return normalized direction#1321
BotellaA merged 5 commits into
v18from
fix/remove_segment_normalized_direction

BenPinet commented Aug 14, 2026

Uh oh!

github-actions Bot commented Aug 14, 2026 •

edited

Loading

Uh oh!

panquez Aug 14, 2026

Uh oh!

panquez Aug 14, 2026

Uh oh!

Uh oh!

BotellaA commented Aug 18, 2026

Uh oh!

BotellaA commented Aug 19, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

		const auto P1mP0 = segment0.direction() * segment0.length();
		const auto Q1mQ0 = segment1.direction() * segment1.length();

Uh oh!

Uh oh!

Conversation

BenPinet commented Aug 14, 2026

Uh oh!

github-actions Bot commented Aug 14, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Cpp-Linter Report ⚠️

Uh oh!

panquez Aug 14, 2026

Choose a reason for hiding this comment

Uh oh!

panquez Aug 14, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

BotellaA commented Aug 18, 2026

Uh oh!

BotellaA commented Aug 19, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

github-actions Bot commented Aug 14, 2026 •

edited

Loading